/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package pl.otros.logview.accept.query.org.apache.log4j.rule;

import java.util.Collection;
import java.util.LinkedList;
import java.util.Locale;
import java.util.Stack;

/**
 * A Factory class which, given a string representation of the rule, and a context stack, will return a Rule ready for evaluation against events. If an operator
 * is requested that isn't supported, an IllegalArgumentException is thrown.
 * 
 * @author Scott Deboy (sdeboy@apache.org)
 * @author Krzysztof Otrebski
 */
public final class RuleFactory {

  /**
   * Singleton instance.
   */
  private static final RuleFactory FACTORY = new RuleFactory();
  /**
   * Rules.
   */
  private static final Collection<String> RULES = new LinkedList<String>();
  /**
   * AND operator literal.
   */
  private static final String AND_RULE = "&&";
  /**
   * OR operator literal.
   */
  private static final String OR_RULE = "||";
  /**
   * NOT operator literal.
   */
  private static final String NOT_RULE = "!";
  /**
   * Inequality operator literal.
   */
  private static final String NOT_EQUALS_RULE = "!=";
  /**
   * Equality operator literal.
   */
  private static final String EQUALS_RULE = "==";
  /**
   * Partial match operator literal.
   */
  private static final String PARTIAL_TEXT_MATCH_RULE = "~=";
  /**
   * Like operator literal.
   */
  private static final String LIKE_RULE = "like";
  /**
   * Exists operator literal.
   */
  private static final String EXISTS_RULE = "exists";
  /**
   * Less than operator literal.
   */
  private static final String LESS_THAN_RULE = "<";
  /**
   * Greater than operator literal.
   */
  private static final String GREATER_THAN_RULE = ">";
  /**
   * Less than or equal operator literal.
   */
  private static final String LESS_THAN_EQUALS_RULE = "<=";
  /**
   * Greater than or equal operator literal.
   */
  private static final String GREATER_THAN_EQUALS_RULE = ">=";

  static {
    RULES.add(AND_RULE);
    RULES.add(OR_RULE);
    RULES.add(NOT_RULE);
    RULES.add(NOT_EQUALS_RULE);
    RULES.add(EQUALS_RULE);
    RULES.add(PARTIAL_TEXT_MATCH_RULE);
    RULES.add(LIKE_RULE);
    RULES.add(EXISTS_RULE);
    RULES.add(LESS_THAN_RULE);
    RULES.add(GREATER_THAN_RULE);
    RULES.add(LESS_THAN_EQUALS_RULE);
    RULES.add(GREATER_THAN_EQUALS_RULE);
  }

  /**
   * Create instance.
   */
  private RuleFactory() {
    super();
  }

  /**
   * Get instance.
   * 
   * @return rule factory instance.
   */
  public static RuleFactory getInstance() {
    return FACTORY;
  }

  /**
   * Determine if specified string is a known operator.
   * 
   * @param symbol
   *          string
   * @return true if string is a known operator
   */
  public boolean isRule(final String symbol) {
    return ((symbol != null) && (RULES.contains(symbol.toLowerCase(Locale.ENGLISH))));
  }

  /**
   * Create rule from applying operator to stack.
   * 
   * @param symbol
   *          symbol
   * @param stack
   *          stack
   * @return new instance
   */
  public Rule getRule(final String symbol, final Stack<Object> stack) {
    if (AND_RULE.equals(symbol)) {
      return AndRule.getRule(stack);
    }

    if (OR_RULE.equals(symbol)) {
      return OrRule.getRule(stack);
    }

    if (NOT_RULE.equals(symbol)) {
      return NotRule.getRule(stack);
    }

    if (NOT_EQUALS_RULE.equals(symbol)) {
      return NotEqualsRule.getRule(stack);
    }

    if (EQUALS_RULE.equals(symbol)) {
      return EqualsRule.getRule(stack);
    }

    if (PARTIAL_TEXT_MATCH_RULE.equals(symbol)) {
      return PartialTextMatchRule.getRule(stack);
    }

    if (RULES.contains(LIKE_RULE) && LIKE_RULE.equalsIgnoreCase(symbol)) {
      return LikeRule.getRule(stack);
    }

    if (EXISTS_RULE.equalsIgnoreCase(symbol)) {
      return ExistsRule.getRule(stack);
    }

    if (LESS_THAN_RULE.equals(symbol)) {
      return InequalityRule.getRule(LESS_THAN_RULE, stack);
    }

    if (GREATER_THAN_RULE.equals(symbol)) {
      return InequalityRule.getRule(GREATER_THAN_RULE, stack);
    }

    if (LESS_THAN_EQUALS_RULE.equals(symbol)) {
      return InequalityRule.getRule(LESS_THAN_EQUALS_RULE, stack);
    }

    if (GREATER_THAN_EQUALS_RULE.equals(symbol)) {
      return InequalityRule.getRule(GREATER_THAN_EQUALS_RULE, stack);
    }
    throw new IllegalArgumentException("Invalid rule: " + symbol);
  }
}
